2096. Step-By-Step Directions From a Binary Tree Node to Another.go

package leetcode

import (
"github.com/halfrost/LeetCode-Go/structures"
)

// TreeNode define
typeTreeNode= structures.TreeNode

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 * Val int
 * Left *TreeNode
 * Right *TreeNode
 * }
 */

funcgetDirections(root*TreeNode, startValueint, destValueint) string {
sPath, dPath:=make([]byte, 0), make([]byte, 0)
findPath(root, startValue, &sPath)
findPath(root, destValue, &dPath)
size, i:=min(len(sPath), len(dPath)), 0
fori<size {
ifsPath[len(sPath)-1-i] ==dPath[len(dPath)-1-i] {
i++
 } else {
break
 }
 }
sPath=sPath[:len(sPath)-i]
replace(sPath)
dPath=dPath[:len(dPath)-i]
reverse(dPath)
sPath=append(sPath, dPath...)
returnstring(sPath)
}

funcfindPath(root*TreeNode, valueint, path*[]byte) bool {
ifroot.Val==value {
returntrue
 }

ifroot.Left!=nil&&findPath(root.Left, value, path) {
*path=append(*path, 'L')
returntrue
 }

ifroot.Right!=nil&&findPath(root.Right, value, path) {
*path=append(*path, 'R')
returntrue
 }

returnfalse
}

funcreverse(path []byte) {
left, right:=0, len(path)-1
forleft<right {
path[left], path[right] =path[right], path[left]
left++
right--
 }
}

funcreplace(path []byte) {
fori:=0; i<len(path); i++ {
path[i] ='U'
 }
}

funcmin(i, jint) int {
ifi<j {
returni
 }
returnj
}